import java.io.ByteArrayOutputStream;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

public class 点草小学生 {
    private static char[] alphabet;
    private static byte[] codes;
    static String l;
    static 点草小学生 ss;

    static {
        点草小学生.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();
        点草小学生.codes = new byte[0x100];
        点草小学生.l = "";
        int v0;
        for(v0 = 0; v0 < 0x100; ++v0) {
            点草小学生.codes[v0] = -1;
        }

        for(v0 = 65; v0 <= 90; ++v0) {
            点草小学生.codes[v0] = ((byte)(v0 - 65));
        }

        for(v0 = 97; v0 <= 0x7A; ++v0) {
            点草小学生.codes[v0] = ((byte)(v0 - 71));
        }

        for(v0 = 0x30; v0 <= 57; ++v0) {
            点草小学生.codes[v0] = ((byte)(v0 + 4));
        }

        点草小学生.codes[43] = 62;
        点草小学生.codes[0x2F] = 0x3F;
    }

    public 点草小学生() {
        super();
    }

    private byte[] decode(byte[] arg21) {
        int v13;
        byte[] v2 = arg21;
        int v3 = 0;
        int v4 = (v2.length + 3) / 4 * 3;
        if(v2.length > 0 && v2[v2.length - 1] == 61) {
            --v4;
        }

        if(v2.length > 1 && v2[v2.length - 2] == 61) {
            --v4;
        }

        byte[] v5 = new byte[v4];
        int v6 = 0;
        int v7 = 0;
        byte[] v8 = v2;
        int v9;
        for(v9 = 0; v9 < v8.length; ++v9) {
            int v11 = 点草小学生.codes[v8[v9] & 0xFF];
            if(v11 >= 0) {
                int v12 = v6 << 6;
                v6 = v7 + 6;
                v7 = v12 | v11;
                if(v6 >= 8) {
                    v13 = v6 - 8;
                    v5[v3] = ((byte)(v7 >> v13 & 0xFF));
                    ++v3;
                    v6 = v7;
                    v7 = v13;
                }
                else {
                    v13 = v7;
                    v7 = v6;
                    v6 = v13;
                }
            }
        }

        int v15 = v3;
        byte[] v16 = v5;
        try {
            if(v15 == v16.length) {
                return v5;
            }

            throw new Exception("miscalculated data length!");
        }
        catch(Exception v15_1) {
        }

        return v5;
    }

    private byte[] encode(byte[] arg20) {
        Integer v6;
        Integer v5;
        byte[] v1 = arg20;
        byte[] v2 = new byte[(v1.length + 2) / 3 * 4];
        int v3 = 0;
        int v4 = 0;
        while(v4 < v1.length) {
            int v7 = (v1[v4] & 0xFF) << 8;
            if(v4 + 1 < v1.length) {
                v7 |= v1[v4 + 1] & 0xFF;
                v5 = new Integer(1);
            }
            else {
                v5 = null;
            }

            v7 <<= 8;
            if(v4 + 2 < v1.length) {
                v7 |= v1[v4 + 2] & 0xFF;
                v6 = new Integer(1);
            }
            else {
                v6 = null;
            }

            byte[] v10 = v2;
            int v11 = v3 + 3;
            char[] v12 = 点草小学生.alphabet;
            int v13 = v6 != null ? v7 & 0x3F : 0x40;
            v10[v11] = ((byte)v12[v13]);
            int v8 = v7 >> 6;
            v10 = v2;
            v11 = v3 + 2;
            v12 = 点草小学生.alphabet;
            v13 = v5 != null ? v8 & 0x3F : 0x40;
            v10[v11] = ((byte)v12[v13]);
            v7 = v8 >> 6;
            v2[v3 + 1] = ((byte)点草小学生.alphabet[v7 & 0x3F]);
            v2[v3] = ((byte)点草小学生.alphabet[v7 >> 6 & 0x3F]);
            v4 += 3;
            v3 += 4;
        }

        return v2;
    }

    public byte[] encoder(byte[] arg16) throws Exception {
        点草小学生 v0 = this;
        byte[] v1 = arg16;
        int v2 = 0;
        if(v1 == null) {
            throw new Exception("Data error");
        }

        Deflater v3 = new Deflater();
        v3.reset();
        v3.setInput(v1);
        v3.finish();
        ByteArrayOutputStream v4 = new ByteArrayOutputStream();
        byte[] v5 = new byte[0x400];
        while(!v3.finished()) {
            v4.write(v5, 0, v3.deflate(v5));
        }

        byte[] v6 = v4.toByteArray();
        if(!点草小学生.l.equals("")) {
            while(v2 < v6.length) {
                byte[] v7 = 点草小学生.l.getBytes();
                v6[v2] = ((byte)(((char)(v7[v2 % v7.length] ^ v6[v2]))));
                ++v2;
            }
        }

        return v0.encode(v6);
    }

    public static 点草小学生 getfriend() {
        if(点草小学生.ss == null) {
            点草小学生.ss = new 点草小学生();
        }

        return 点草小学生.ss;
    }

    public byte[] m(byte[] arg14) throws Exception {
        byte[] v2;
        点草小学生 v0 = this;
        byte[] v1 = arg14;
        if(v1 == null) {
            throw new Exception("Data error");
        }

        byte[] v3 = v0.decode(v1);
        if(!点草小学生.l.equals("")) {
            int v4;
            for(v4 = 0; v4 < v3.length; ++v4) {
                v2 = 点草小学生.l.getBytes();
                v3[v4] = ((byte)(((char)(v2[v4 % v2.length] ^ v3[v4]))));
            }
        }

        Inflater v4_1 = new Inflater();
        v4_1.reset();
        v4_1.setInput(v3);
        ByteArrayOutputStream v5 = new ByteArrayOutputStream();
        v2 = new byte[0x400];
        while(!v4_1.finished()) {
            v5.write(v2, 0, v4_1.inflate(v2));
        }

        return v5.toByteArray();
    }
}

